home *** CD-ROM | disk | FTP | other *** search
/ Clickx 96 / Clickx 96.iso / software / tools / tool / xbmc-10.1.exe / addons / script.module.pil / lib / PIL / TgaImagePlugin.py < prev    next >
Encoding:
Python Source  |  2009-06-13  |  5.0 KB  |  202 lines
  1. #
  2. # The Python Imaging Library.
  3. # $Id$
  4. #
  5. # TGA file handling
  6. #
  7. # History:
  8. # 95-09-01 fl   created (reads 24-bit files only)
  9. # 97-01-04 fl   support more TGA versions, including compressed images
  10. # 98-07-04 fl   fixed orientation and alpha layer bugs
  11. # 98-09-11 fl   fixed orientation for runlength decoder
  12. #
  13. # Copyright (c) Secret Labs AB 1997-98.
  14. # Copyright (c) Fredrik Lundh 1995-97.
  15. #
  16. # See the README file for information on usage and redistribution.
  17. #
  18.  
  19.  
  20. __version__ = "0.3"
  21.  
  22. import Image, ImageFile, ImagePalette
  23.  
  24.  
  25. #
  26. # --------------------------------------------------------------------
  27. # Read RGA file
  28.  
  29. def i16(c):
  30.     return ord(c[0]) + (ord(c[1])<<8)
  31.  
  32. def i32(c):
  33.     return ord(c[0]) + (ord(c[1])<<8) + (ord(c[2])<<16) + (ord(c[3])<<24)
  34.  
  35.  
  36. MODES = {
  37.     # map imagetype/depth to rawmode
  38.     (1, 8):  "P",
  39.     (3, 1):  "1",
  40.     (3, 8):  "L",
  41.     (2, 16): "BGR;5",
  42.     (2, 24): "BGR",
  43.     (2, 32): "BGRA",
  44. }
  45.  
  46.  
  47. def _accept(prefix):
  48.     return prefix[0] == "\0"
  49.  
  50. ##
  51. # Image plugin for Targa files.
  52.  
  53. class TgaImageFile(ImageFile.ImageFile):
  54.  
  55.     format = "TGA"
  56.     format_description = "Targa"
  57.  
  58.     def _open(self):
  59.  
  60.         # process header
  61.         s = self.fp.read(18)
  62.  
  63.         id = ord(s[0])
  64.  
  65.         colormaptype = ord(s[1])
  66.         imagetype = ord(s[2])
  67.  
  68.         depth = ord(s[16])
  69.  
  70.         flags = ord(s[17])
  71.  
  72.         self.size = i16(s[12:]), i16(s[14:])
  73.  
  74.         # validate header fields
  75.         if id != 0 or colormaptype not in (0, 1) or\
  76.            self.size[0] <= 0 or self.size[1] <= 0 or\
  77.            depth not in (1, 8, 16, 24, 32):
  78.             raise SyntaxError, "not a TGA file"
  79.  
  80.         # image mode
  81.         if imagetype in (3, 11):
  82.             self.mode = "L"
  83.             if depth == 1:
  84.                 self.mode = "1" # ???
  85.         elif imagetype in (1, 9):
  86.             self.mode = "P"
  87.         elif imagetype in (2, 10):
  88.             self.mode = "RGB"
  89.             if depth == 32:
  90.                 self.mode = "RGBA"
  91.         else:
  92.             raise SyntaxError, "unknown TGA mode"
  93.  
  94.         # orientation
  95.         orientation = flags & 0x30
  96.         if orientation == 0x20:
  97.             orientation = 1
  98.         elif not orientation:
  99.             orientation = -1
  100.         else:
  101.             raise SyntaxError, "unknown TGA orientation"
  102.  
  103.         self.info["orientation"] = orientation
  104.  
  105.         if imagetype & 8:
  106.             self.info["compression"] = "tga_rle"
  107.  
  108.         if colormaptype:
  109.             # read palette
  110.             start, size, mapdepth = i16(s[3:]), i16(s[5:]), i16(s[7:])
  111.             if mapdepth == 16:
  112.                 self.palette = ImagePalette.raw("BGR;16",
  113.                     "\0"*2*start + self.fp.read(2*size))
  114.             elif mapdepth == 24:
  115.                 self.palette = ImagePalette.raw("BGR",
  116.                     "\0"*3*start + self.fp.read(3*size))
  117.             elif mapdepth == 32:
  118.                 self.palette = ImagePalette.raw("BGRA",
  119.                     "\0"*4*start + self.fp.read(4*size))
  120.  
  121.         # setup tile descriptor
  122.         try:
  123.             rawmode = MODES[(imagetype&7, depth)]
  124.             if imagetype & 8:
  125.                 # compressed
  126.                 self.tile = [("tga_rle", (0, 0)+self.size,
  127.                               self.fp.tell(), (rawmode, orientation, depth))]
  128.             else:
  129.                 self.tile = [("raw", (0, 0)+self.size,
  130.                               self.fp.tell(), (rawmode, 0, orientation))]
  131.         except KeyError:
  132.             pass # cannot decode
  133.  
  134. #
  135. # --------------------------------------------------------------------
  136. # Write TGA file
  137.  
  138. def o16(i):
  139.     return chr(i&255) + chr(i>>8&255)
  140.  
  141. def o32(i):
  142.     return chr(i&255) + chr(i>>8&255) + chr(i>>16&255) + chr(i>>24&255)
  143.  
  144. SAVE = {
  145.     "1": ("1", 1, 0, 3),
  146.     "L": ("L", 8, 0, 3),
  147.     "P": ("P", 8, 1, 1),
  148.     "RGB": ("BGR", 24, 0, 2),
  149.     "RGBA": ("BGRA", 32, 0, 2),
  150. }
  151.  
  152. def _save(im, fp, filename, check=0):
  153.  
  154.     try:
  155.         rawmode, bits, colormaptype, imagetype = SAVE[im.mode]
  156.     except KeyError:
  157.         raise IOError("cannot write mode %s as TGA" % im.mode)
  158.  
  159.     if check:
  160.         return check
  161.  
  162.     if colormaptype:
  163.         colormapfirst, colormaplength, colormapentry = 0, 256, 24
  164.     else:
  165.         colormapfirst, colormaplength, colormapentry = 0, 0, 0
  166.  
  167.     if im.mode == "RGBA":
  168.         flags = 8
  169.     else:
  170.         flags = 0
  171.  
  172.     orientation = im.info.get("orientation", -1)
  173.     if orientation > 0:
  174.         flags = flags | 0x20
  175.  
  176.     fp.write("\000" +
  177.              chr(colormaptype) +
  178.              chr(imagetype) +
  179.              o16(colormapfirst) +
  180.              o16(colormaplength) +
  181.              chr(colormapentry) +
  182.              o16(0) +
  183.              o16(0) +
  184.              o16(im.size[0]) +
  185.              o16(im.size[1]) +
  186.              chr(bits) +
  187.              chr(flags))
  188.  
  189.     if colormaptype:
  190.         fp.write(im.im.getpalette("RGB", "BGR"))
  191.  
  192.     ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, orientation))])
  193.  
  194. #
  195. # --------------------------------------------------------------------
  196. # Registry
  197.  
  198. Image.register_open("TGA", TgaImageFile, _accept)
  199. Image.register_save("TGA", _save)
  200.  
  201. Image.register_extension("TGA", ".tga")
  202.